#include "CKConfig.h"



namespace K_Engine
{
	bool CKConfig::LoadConfig(std::string config_json)
	{
		int err = json.LoadFile(config_json);
		if( 0 != err)
		{
			//存在错误
			SetLastError("配置文件语法错误");
			return false;
		}
		else
		{
			//加载根
			KJson::KJsonObject* obj = 
				static_cast<KJson::KJsonObject*>(json.GetKJsonValueBase());
			if(NULL == obj)
			{
				SetLastError("找不到根节点");
				return false;
			}
			
			//加载localhost节点
			KJson::KJsonObject* localhost = 
				static_cast<KJson::KJsonObject*>((*obj)["localhost"]);
			if(NULL == localhost)
			{
				SetLastError("找不到localhost节点");
				return false;
			}
			
			KJson::KJsonString* host = static_cast<KJson::KJsonString*>((*localhost)["host"]);
			if(NULL == host)
			{
				SetLastError("localhost下找不到host节点");
				return false;
			}
			m_localhost = host->strGetString();
			
			KJson::KJsonString* name = static_cast<KJson::KJsonString*>((*localhost)["name"]);
			if(NULL == name)
			{
				SetLastError("localhost下找不到name节点");
				return false;
			}
			m_localname = name->strGetString();
			
			//----------------------------------------------------------------------------------
			
			//加载是否开启分布式规则
			KJson::KJsonBoolean* distributed = static_cast<KJson::KJsonBoolean*>((*obj)["distributed"]);
			if(NULL == distributed)
			{
				SetLastError("找不到distributed节点");
				return false;
			}
			if(distributed->bGetBoolean())
			{
				//分布式工作
				//-------------------忽略------------------------
				KJson::KJsonObject* distributed_server = static_cast<KJson::KJsonObject*>((*obj)["distributed_server"]);
				if(NULL == distributed_server)
				{
					return false;
				}
			}
			else
			{
				//单机工作
				KJson::KJsonObject* server = static_cast<KJson::KJsonObject*>((*obj)["server"]);
				if(NULL == server)
				{
					SetLastError("找不到server节点");
					return false;
				}
				
				//缓存消息文件
				KJson::KJsonString* msgtempfile = static_cast<KJson::KJsonString*>((*server)["msgtempfile"]);
				if(NULL == msgtempfile)
				{
					SetLastError("找不到msgtempfile节点");
					return false;
				}
				m_msgtempfile = msgtempfile->strGetString();
				
				//线程池线程数量
				KJson::KJsonInteger* threadsize = static_cast<KJson::KJsonInteger*>((*server)["thread-size"]);
				if(NULL == threadsize)
				{
					SetLastError("找不到thread-size节点");
					return false;
				}
				m_threadsize = threadsize->nGetInteger();
				
				//加载哪一个工作模块
				KJson::KJsonArray* rule = static_cast<KJson::KJsonArray*>((*server)["rule"]);
				if(NULL == rule)
				{
					SetLastError("找不到rule节点");
					return false;
				}
				int size = rule->nGetSize();
				if( 0 == size)
				{
					SetLastError("rule节点为空");
					return false;
				}
				for(int i = 0 ; i < size ; i ++)
				{
					m_rule.push_back(
						static_cast<KJson::KJsonString*>((*rule)[i])->strGetString()
					);
				}
			}
		}
		return true;
	}
	
	
	std::string CKConfig::strGetLocalhost() const
	{
		return m_localhost;
	}
	
	
	std::string CKConfig::strGetLocalName() const
	{
		return m_localname;
	}
	
	
	std::string CKConfig::strGetRule(int n) const
	{
		return m_rule[n];
	}

	
	int CKConfig::nSizeOfRule() const
	{
		return m_rule.size();
	}
	
	
	int CKConfig::nThreadSize() const
	{
		return m_threadsize;
	}
	
	
	void CKConfig::SetLastError(std::string strLastError)
	{
		m_strLastError = strLastError;
	}
	
	
	std::string CKConfig::strGetLastError() const
	{
		return m_strLastError;
	}
	
	
	std::string CKConfig::strGetMsgTempFile() const
	{
		return m_msgtempfile;
	}
}